package com.AdvancedDemos.Stream流操作;

import java.util.ArrayList;
import java.util.List;

public class Stream流收集方法 {
    public static void main(String[] args) {
        /*
        收集方法用于将流中剩余的数据收集起来,变成一个数组,单列集合,双列集合...
         */
        //1. <A> A[] toArray(IntFunction<A[]> generator)
        ArrayList<Integer> integers = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

//        //获取所有的偶数,并存储到数组中
//        Integer[] integers1 = integers.stream().filter(new Predicate<Integer>() {
//            @Override
//            public boolean test(Integer integer) {
//                return integer % 2 == 0;
//            }
//        }).toArray(new IntFunction<Integer[]>() {//<>中必须改成要的数组的类型,此处为Integer[]
//                       @Override
//                       public Integer[] apply(int value) {//value是当前流中数据的个数
//                           return new Integer[value];//定义数组长度为value,自动将stream中的数据存入该返回数组中
//                       }
//                   }
//                /*
//                简化为Lambda表达式
//                value -> {
//                    return new Integer[value];
//                }*/
//
//                //toArray(元素类型[]::new);
//                /*
//                简化为方法引用
//                Integer[]::new
//                */
//        );
//        System.out.println(Arrays.toString(integers1));//[2, 4, 6, 8, 10]


//        //2. <R,A> R collect(Collector<? super T,A,R> collector) --- 将流中剩余数据汇集到方法中,但是该方法不负责创建任何容器
//        //容器创建,需要借用Collectors收集者工具,创建集合,传递到方法中
//
//
//        //Collectors中的静态方法①,static <T> Collectors<T,?,List<T>> toList()
//        List<Integer> collect = integers.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toList());//表示收集到List中
//        System.out.println(collect);//[2, 4, 6, 8, 10]
//        collect.add(20);//该List集合可以正常添加数据,删除,修改,获取
//        System.out.println(collect);//[2, 4, 6, 8, 10, 20]
//
//
//        //Collectors中的静态方法②,static <T> Collectors<T,?,Set<T>> toSet()
//        ArrayList<Integer> integers1 = new ArrayList<>(List.of(1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10));
//        Set<Integer> collect = integers1.stream().filter(interger -> interger % 2 == 0).collect(Collectors.toSet());//表示收集到Set中
//        System.out.println(collect);//[2, 4, 6, 8, 10] set中自动去重 去重依赖的是元素的hashCode()和equals(),也即自定义类去重需要重写hashCode()和equals()
//
//
//        //Collectors中的静态方法③,static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
//        //toMap(从流中元素获取键的操作,从流中元素获取值的操作)
//        //参数一:new Function<流中数据类型,转换后键的类型>
//        //参数二:new Function<流中数据类型,转换后值的类型>
//        ArrayList<String> strings = new ArrayList<>(List.of("001-张三", "002-李四", "003-ikun"));
//        Map<String, String> collect = strings.stream().collect(Collectors.toMap(new Function<String, String>() {//第一个String是流中元素的类型,第二个String是键元素的类型
//            @Override
//            public String apply(String s) {//s代表流中的每个数据,要加工成键返回
//                return s.split("-")[0];
//            }
//        }, new Function<String, String>() {//第一个String是流中元素的类型,第二个String是值元素的类型
//            @Override
//            public String apply(String s) {//s代表流中的每个数据,要加工成值返回
//                return s.split("-")[1];
//            }
//        }));
//
//        System.out.println(collect);//{001=张三, 002=李四, 003=ikun}
//
//        /*
//        也可以自己建一个map集合,然后遍历,切分,存键值对
//         */
//        Map<String, String> myMap = new HashMap<>();
//        for (String string : strings) {
//            String[] split = string.split("-");
//            myMap.put(split[0], split[1]);
//        }
//        System.out.println(myMap);//{001=张三, 002=李四, 003=ikun}

    }
}
